关于一个应用分枝界限法解决最小顶点覆盖问题的程序说明

最新推荐文章于 2022-02-25 19:38:17 发布
最新推荐文章于 2022-02-25 19:38:17 发布
阅读量3.2k 收藏 6
点赞数
文章标签： class insert delete 扩展 c 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhshow/article/details/5481370
版权

 

//程序下载自：http://download.csdn.net/source/1930594

//头文件Minheap.h

 

template <class Type>

class MinHeap                                        //最小堆类；

{

public:                             

MinHeap(Type a[], int n);                          //带两参数的构造函数，在此程序中没有应用；

MinHeap(int ms);                                      //构造函数重载，只初始化堆的大小，对堆中结点不初始化；另外，堆元素的存储是以数组

~MinHeap();                                             //形式，且无父、子指针，访问父亲结点，利用数组标号进行；

bool Insert(const Type &x);                       //插入堆中一个元素；

bool RemoveMin(Type &x);                          //删除堆顶最小结点；

void MakeEmpty();                                              //使堆为空

bool IsEmpty();

bool IsFull();

int Size();

protected:

void FilterDown(const int start, const int endOfHeap);                                  / /自顶向下构造堆

void FilterUp(const int start);                                                                        //自底向上构造堆

private:

Type *heap;                                                                 

int maxSize;

const int defaultSize;

int currentSize;                                                                                           //堆当前结点个数大小

};

 

template <class Type>

MinHeap<Type>::MinHeap(int ms):defaultSize(100)

{

maxSize=ms>defaultSize ? ms : defaultSize;

heap=new Type[maxSize];

currentSize=0;

}

 

template <class Type>

MinHeap<Type>::MinHeap(Type a[], int n):defaultSize(100)

{

maxSize=n>defaultSize ? n : defaultSize;

heap=new Type[maxSize];

currentSize=n;

for (int i=0; i<n; i++) heap[i]=a[i];

int curPos=(currentSize-2)/2;

while (curPos>=0)

{

   FilterDown(curPos, currentSize-1);

   curPos--;

}

}

 

template <class Type>

MinHeap<Type>::~MinHeap()

{

delete []heap;

}

 

template <class Type>

void MinHeap<Type>::FilterDown(const int start, const int endOfHeap)

{

int i=start, j=i*2+1;

Type temp=heap[i];

while (j<=endOfHeap)

{

   if (j<endOfHeap&&heap[j]>heap[j+1]) j++;                            

   if (temp<heap[j]) break;                        

   else

   {

    heap[i]=heap[j];

    i=j;

    j=2*i+1;

   }

}

heap[i]=temp;

}

 

template <class Type>

void MinHeap<Type>::FilterUp(const int start)

{

int i=start, j=(i-1)/2;

Type temp=heap[i];

while (i>0)

{

   if (temp>=heap[j]) break;

   else

   {

    heap[i]=heap[j];

    i=j;

    j=(i-1)/2;

   }

}

heap[i]=temp;

}

 

template <class Type>

bool MinHeap<Type>::RemoveMin(Type &x)

{

if (IsEmpty())

{

   cerr<<"Heap empty!"<<endl;

   return false;

}

x=heap[0];

heap[0]=heap[currentSize-1];

currentSize--;

FilterDown(0, currentSize-1);

return true;

}

 

template <class Type>

bool MinHeap<Type>::Insert(const Type &x)

{

if (IsFull())

{

   cerr<<"Heap Full!"<<endl;

        return false;

}

heap[currentSize]=x;

FilterUp(currentSize);

currentSize++;

return true;

}

 

template <class Type>

bool MinHeap<Type>::IsEmpty()

{

return currentSize==0;

}

 

template <class Type>

bool MinHeap<Type>::IsFull()

{

return currentSize==maxSize;

}

 

template <class Type>

void MinHeap<Type>::MakeEmpty()

{

currentSize=0;

}

 

template <class Type>

int MinHeap<Type>::Size()

{

return currentSize;

}

//MinCover.cpp
#include<iostream.h>
#include<fstream.h>
#include"MinHeap.h"
int *p;
//最小堆结点
class HeapNode                                                                 //堆结点类；
{
friend class VC;
public:
operator int()const{return cn;}                                       //重载运算符，比较两个结点；
private:
   int i,cn,*x,*c;                                                          //i标示堆中结点号，cn标示当前加入的覆盖顶点中权重之和，x数组标示那些                                                                                          //顶点加入了覆盖顶点的行列，c数组标示X中的覆盖顶点中所有的邻接                                                                                            // 顶点；
                                                                                       
};
class VC                                                              // VC类用来对堆中结点内部的的操作，
{
friend MinCover(int **,int [],int);                          
private:
void BBVC();
bool cover(HeapNode E);
void AddLiveNode(MinHeap<HeapNode>&H,HeapNode E,int cn,int i,bool ch);
int **a,n,*w,*bestx,bestn;
};
void VC::BBVC()
{
MinHeap<HeapNode>H(100000);   //建立初始空堆；
HeapNode E;
E.x=new int[n+1];
E.c=new int[n+1];
for(int j=1;j<=n;j++)
{
   E.x[j]=E.c[j]=0;
}
int i=1,cn=0;  //开始时;
while(true)
{
   if(i>n)
   {
    if(cover(E))
    {
     for(int j=1;j<=n;j++)
      bestx[j]=E.x[j];
     bestn=cn;
     break;
    }
   }
   else
   {
    if(!cover(E))
     AddLiveNode(H,E,cn,i,true);                  //加入结点标号为i 的结点到顶点覆盖集中，并把更新后的结点再插入堆中；
    AddLiveNode(H,E,cn,i,false);                  //不把结点标号为 i 的结点加入到顶点覆盖集中，并把更新后的结点插入堆中；
   }
   if(H.IsEmpty())break;
   H.RemoveMin(E);                                   //把 堆顶点先移除给E; 
   cn=E.cn;
   i=E.i+1;                                                        
}
}
//cover
bool VC::cover(HeapNode E)
{
for(int j=1;j<=n;j++)
{
   if(E.x[j]==0&&E.c[j]==0)
    return false;        //存在任意一条边的两个顶点都为0的情况下，为未覆盖情况；X[j]记录覆盖顶点，c[j]记录与覆盖顶点相连的顶点；
}                             //0表征未覆盖，1表征已覆盖；
return true;
}
void VC::AddLiveNode(MinHeap<HeapNode> &H,HeapNode E,int cn,int i,bool ch)
{
HeapNode N;
N.x=new int[n+1];
N.c=new int[n+1];
for(int j=1;j<=n;j++)
{
   N.x[j]=E.x[j];
   N.c[j]=E.c[j];
}
N.x[i]=ch?1:0;
if(ch)
{
   N.cn=cn+w[i];                                                     / /记录I顶点是否加入覆盖的行列中；
   for(int j=1;j<=n;j++)
    if(a[i][j]>0)                                                        //如果i,j相邻，刚把j顶点加入覆盖邻接顶点集中；
     N.c[j]++;                                                          
}
else 
{
   N.cn=cn;
}
N.i=i;
H.Insert(N);   
              
}               
int MinCover(int **a,int v[],int n)
{
VC Y;
Y.w=new int[n+1];
for(int j=1;j<=n;j++)
{
   Y.w[j]=v[j];       //初始化VC类对象Y;
}
Y.a=a; 
Y.n=n;
Y.bestx=v;        //将地址赋予bestx，
Y.BBVC();
return Y.bestn;      //bestn是最后的最小顶点覆盖集权重；
}                  
int main()
{
int u,v;
int n,c;
ifstream infile("input.txt");
if(!infile)
{
   cout<<"Can't open input.txt"<<endl;
   return 0;
}
ofstream outfile("output.txt");
if(!outfile)
{
   cout<<"Can't open output.txt"<<endl;
   return 0;
}
infile>>n>>c;
//Make2DArray(a,n+1,n+1);
int **a;
a=new int *[n+1];
for(int k=0;k<=n;k++)
   a[k]=new int[n+1];
for(int i=0;i<=n;i++)
   for(int j=0;j<=n;j++)
    a[i][i]=0;
p=new int[n+1];
for(i=1;i<=n;i++)
   infile>>p[i];
for(i=1;i<=c;i++)
{
   infile>>u>>v;
   a[u][v]=1;
   a[v][u]=1;
}
cout<<MinCover(a,p,n)<<endl;
for(i=1;i<=n;i++)
   cout<<p[i]<<" ";
cout<<endl;
return 0;
}
'input.txt'
7 7
1 100 1 1 1 100 10
1 6
2 4
2 5
3 6
4 5 
4 6
6 7
说明：在文章中，顶点与结点是两个不同的概念，结点中有记录当前加入顶点覆盖集的 i,有加入顶点覆盖集中的x[],有加入与顶点覆盖集邻接的c[]顶点集；
此程序的运行流程：首先是初始建最小堆过程，把每个顶点插入到堆中，在每个顶点的内部，X[]数组就是记录此时的顶点覆盖集，然后选取此结点内部顶点覆盖集权重之和cn最小的顶点做为扩展结点，然后以比此顶点标号大1的结点为参考(i = E.i + 1)，分别插入两个结点到堆中，一个是 i 顶点加入顶点覆盖集后的结点，一个是 i顶点没有加入顶点覆盖集后的结点，然后重新建堆，再重新移出堆结点，重复如此，直到所有顶点都被标记进x[]或c[]中（）。

 

zhutuanfei
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法设计与分析: 6-3 最小权顶点覆盖问题
`!_`5 81_09
07-23 7662
6-3 最小权顶点覆盖问题 问题描述 给定一个赋权无向图 G=(V,E)，每个顶点 v∈V 都有一个权值 w(v)。如果 U⊆VU⊆VU\subseteq V，且对任意(u,v)∈E 有 u∈U 或 v∈U，就称 U 为图 G 的一个顶点覆盖。G 的最小权顶点覆盖是指 G 中所含顶点权之和最小的顶点覆盖。 对于给定的无向图 G，设计一个优先队列式分支限界法，计算 G 的最小权顶点覆盖。 ...
算法设计-分支界限法——单源最短路径问题
weixin_44034024的博客
12-22 1万+
算法介绍 分支界限法： 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。 在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。 此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。 与回溯法的区别： （1）求解目标：回溯法的求解目标是找出解空间树中满足约束条件的所有解
算法分支定界法C语言程序,常用算法大全－分枝定界
weixin_32311823的博客
05-19 931
任何美好的事情都有结束的时候。现在我们学习的是本书的最后一章。幸运的是，本章用到的大部分概念在前面各章中已作了介绍。类似于回溯法，分枝定界法在搜索解空间时，也经常使用树形结构来组织解空间(常用的树结构是第1 6章所介绍的子集树和排列树)。然而与回溯法不同的是，回溯算法使用深度优先方法搜索树结构，而分枝定界一般用宽度优先或最小耗费方法来搜索这些树。本章与第1 6章所考察的应用完全相同，因此，可以很容...
分枝限界法求TSP问题--C++/C
gardenpalace的博客
12-07 4978
旅行商问题（TSP）：给定一系列城市和每对城市之间的距离，求解访问每一座城市一次并回到起始城市的最短回路。它是组合优化中的一个NP困难问题，在运筹学和理论计算机科学中非常重要。 这篇文章里介绍一下基于分支限界法的TSP算法。 对于TSP，我们需要利用上界和下界来对BFS进行剪枝，通过不断更新上界和下界，尽可能的排除不符合需求的child，以实现剪枝。最终，当上限和下限等同时，我们可以获得最优的B...
货郎问题：回溯法和限界分支法
weixin_40759186的博客
12-05 4349
这个问题可以堪称一个全排列，[起点，剩下的全排列] import numpy as np class backtracking_Traveling_saleman: # 初始化，明确起点 def __init__(self,graph,start=0): # 顶点的个数 self.vertex_num = len(graph) se...
分支界限法-最短路径问题
xie__jin__cheng的博客
05-30 2532
问题描述 在下图所给的有向图G中，每一边都有一个非负边权。要求图G的从源顶点s到目标顶点t之间的最短路径。 代码 #include <iostream> #include <vector> #include <queue> #include <limits> #include <iterator> using namespace std;...
使用分支限界法解决单源最短路径问题。
z2431435的博客
05-30 1万+
#include<iostream> #include<cstdio> #include<queue> using namespace std; typedef struct ArcCell{ int weight;//保存权值 weight=1说明一开始就输入了这条边，=0说明这两个点之间没有边 int min_length;//存储最短路径长度 }ArcCell,AdjMaxtrix[100][100]; typedef struct{
用c语言程序验证装载问题算法,算法习题——选择题
weixin_32175667的博客
05-22 2235
1、关于算法的说法中正确的有(C)。Ⅰ.求解某一类问题的算法是唯一的(如：冒泡排序可以用：穷举法、递归)Ⅱ.算法必须在有限步操作之后停止Ⅲ.算法的每一步操作必须是明确的，不能有歧义或含义模糊Ⅳ.算法执行后一定产生确定的结果A.1个 B.2个 C.3个 D.4个算法设计的目标：(1)正确性：正确地执行预先规定的功能和性能要求。(2)可使用性...
分支定界法——旅行商(TSP)问题
热门推荐
Mind_V的博客
07-01 3万+
问题描述给定一个n顶点网络（有向或无向），找出一个包含n个顶点且具有最小耗费的换路。任何一个包含网络所有顶点的换路称为一个旅行。旅行商问题（Traveling Salesman Problem，TSP）是要寻找一条耗费最少的旅行。 图1 四顶点网络如图1是一个四顶点无向网络。这个网络的一些旅行：1,2,4,
算法：分枝界限法.doc
11-24
分枝界限法是一种用于解决最优化问题的有效算法，尤其适用于处理约束条件下的整数规划问题。其核心思想是通过不断将问题分解为子问题，并为每个子问题设置一个界限，以逐步缩小搜索范围，最终找到最优解。以下是分枝...
用分枝界限 回溯+剪枝 动态规划 解决01背包问题
11-24
问题描述：给定一个容量为C的背包及n个重量为wi，价值 为p1的物品，要求把物品装入背包，是背包的价值最大， 此类问题为背包问题。物品或者装入背包，或者不装入背 包，称之为0/1被包问题 假设xi表示物品i被装入背包...
C++拉斯维加斯算法结合分枝限界算法解决电路板布线问题.zip
最新发布
10-29
C++拉斯维加斯算法结合分枝限界算法解决电路板布线问题.zipC++拉斯维加斯算法结合分枝限界算法解决电路板布线问题.zipC++拉斯维加斯算法结合分枝限界算法解决电路板布线问题.zipC++拉斯维加斯算法结合分枝限界算法...
旅行商问题分枝界限法(优化队列)
11-21
在应用分枝界限法解决旅行商问题时，通常会经历以下步骤： 1. **初始化**：创建根节点，包含所有城市的连接，边界值设为无穷大，表示尚未探索任何路径。 2. **分枝**：选择一个未访问的城市与已访问的城市形成一个新...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8839
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3299
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 6400
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1553
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2499
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
用java编写一个实验程序，采用分枝限界法求解4皇后问题的一个解
06-03
好的，以下是使用Java语言编写的4皇后问题求解程序，采用分枝限界法： ```java public class NQueenProblem { private static int N = 4; // 皇后数量 private static int[] board = new int[N]; // 存储棋盘 /...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值